home *** CD-ROM | disk | FTP | other *** search
/ Java Programmer's Toolkit / Java Programmer's Toolkit.iso / hotjava3 / hotjava3.exe / hotjava / classsrc / java / io / OutputStreamBuffer.java < prev    next >
Encoding:
Java Source  |  1995-08-11  |  3.7 KB  |  141 lines
  1. /*
  2.  * @(#)OutputStreamBuffer.java    1.12 95/01/31 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. package java.io;
  21.  
  22. /**
  23.  * This class implements a buffer that can be
  24.  * used as an OutputStream. The buffer automatically
  25.  * grows when data is written to the stream.
  26.  * The data can be retrieved using toByteArray() and
  27.  * toString().
  28.  * @version     1.12, 31 Jan 1995
  29.  * @author    Arthur van Hoff
  30.  */
  31. public
  32. class OutputStreamBuffer extends OutputStream {
  33.     /** 
  34.      * The buffer
  35.      */
  36.     protected byte buf[];
  37.  
  38.     /**
  39.      * The number of bytes in the buffer
  40.      */
  41.     protected int count;
  42.  
  43.     /**
  44.      * Create a new OutputStreamBuffer
  45.      */
  46.     public OutputStreamBuffer() {
  47.     this(32);
  48.     }
  49.  
  50.     /**
  51.      * Creates a new OutputStreamBuffer, given an initial size.
  52.      * @param size initial size
  53.      */
  54.     public OutputStreamBuffer(int size) {
  55.     buf = new byte[size];
  56.     }
  57.  
  58.     /**
  59.      * Writes a byte to the buffer.
  60.      * @param b    the byte
  61.      */
  62.     public synchronized void write(int b) {
  63.     int newcount = count + 1;
  64.     if (newcount > buf.length) {
  65.         byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
  66.         System.arraycopy(buf, 0, newbuf, 0, count);
  67.         buf = newbuf;
  68.     }
  69.     buf[count] = (byte)b;
  70.     count = newcount;
  71.     }
  72.  
  73.     /**
  74.      * Writes bytes to the buffer.
  75.      * @param b    the data to be written
  76.      * @param off    the start offset in the data
  77.      * @param len    the number of bytes that are written
  78.      */
  79.     public synchronized void write(byte b[], int off, int len) {
  80.     int newcount = count + len;
  81.     if (newcount > buf.length) {
  82.         byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
  83.         System.arraycopy(buf, 0, newbuf, 0, count);
  84.         buf = newbuf;
  85.     }
  86.     System.arraycopy(b, off, buf, count, len);
  87.     count = newcount;
  88.     }
  89.  
  90.     /**
  91.      * Writes the contents of the buffer to another stream.
  92.      * @param out    the output stream to write to
  93.      */
  94.     public synchronized void writeTo(OutputStream out) {
  95.     out.write(buf, 0, count);
  96.     }
  97.  
  98.     /**
  99.      * Resets the buffer so that you can use it again without
  100.      * throwing away the already allocated buffer.
  101.      */
  102.     public synchronized void reset() {
  103.     count = 0;
  104.     }
  105.  
  106.     /**
  107.      * Returns a copy of the input data.
  108.      * @return a copy of the the buffered data
  109.      */
  110.     public synchronized byte toByteArray()[] {
  111.     byte newbuf[] = new byte[count];
  112.     System.arraycopy(buf, 0, newbuf, 0, count);
  113.     return newbuf;
  114.     }
  115.  
  116.     /**
  117.      * Returns the current size of the buffer.
  118.      * @return the number of bytes in the buffer
  119.      */
  120.     public int size() {
  121.     return count;
  122.     }
  123.  
  124.     /**
  125.      * Converts input data to a string.
  126.      * @return the string
  127.      */
  128.     public String toString() {
  129.     return new String(toByteArray(), 0);
  130.     }
  131.  
  132.     /**
  133.      * Converts input data to a string. The top 8 bits of 
  134.      * each 16 bit UNICODE character are set to hibyte.
  135.      * @return the string
  136.      */
  137.     public String toString(int hibyte) {
  138.     return new String(toByteArray(), hibyte);
  139.     }
  140. }
  141.